{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/kellydingzx/ecg_notebooks/blob/main/pantompskin.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fRjCYnF-R6ZS"
      },
      "source": [
        "## Imports "
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!wget -r -N -c -np https://physionet.org/files/nsrdb/1.0.0/"
      ],
      "metadata": {
        "id": "G4cejnbiTk5b"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {
        "id": "ELuJyYZER6ZU"
      },
      "outputs": [],
      "source": [
        "import pip\n",
        "import os\n",
        "\n",
        "try:\n",
        "    import wfdb\n",
        "except ModuleNotFoundError:\n",
        "    pip.main(['install', \"wfdb\"])\n",
        "    import wfdb\n",
        "\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "metadata": {
        "id": "4CSWi4tnR6ZU"
      },
      "outputs": [],
      "source": [
        "import sys\n",
        "\n",
        "import readin\n",
        "import display\n",
        "\n",
        "import numpy as np\n",
        "from scipy import signal, ndimage"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def pan_tompkins(input_signal, sampling_frequency, low, high):\n",
        "    filtered_singal = bandpass_filter(input_signal, low, high,sampling_frequency)\n",
        "    moving_avg = moving_window_integration(squaring(derivative(filtered_singal, sampling_frequency\n",
        "                                            )), int(0.15*sampling_frequency))\n",
        "    moving_avg[: int(0.2 * sampling_frequency)] = 0\n",
        "    peaks = detect_peaks(moving_avg, sampling_frequency)\n",
        "\n",
        "    return peaks\n",
        "\n",
        "def detect_peaks(detection, sampling_rate=1000, **kwargs):\n",
        "    \"\"\"Based on https://github.com/berndporr/py-ecg-detectors/\n",
        "    Optimized for vectorized computation.\n",
        "    \"\"\"\n",
        "    min_peak_distance = int(0.3 * sampling_rate)\n",
        "    min_missed_distance = int(0.25 * sampling_rate)\n",
        "\n",
        "    signal_peaks = []\n",
        "\n",
        "    SPKI = 0.0\n",
        "    NPKI = 0.0\n",
        "\n",
        "    last_peak = 0\n",
        "    last_index = -1\n",
        "\n",
        "    peaks, _ = signal.find_peaks(detection, plateau_size=(1, 1))\n",
        "    for index, peak in enumerate(peaks):\n",
        "        peak_value = detection[peak]\n",
        "\n",
        "        threshold_I1 = NPKI + 0.25 * (SPKI - NPKI)\n",
        "        if peak_value > threshold_I1 and peak > last_peak + min_peak_distance:\n",
        "            signal_peaks.append(peak)\n",
        "\n",
        "            # RR_missed threshold is based on the previous eight R-R intervals\n",
        "            if len(signal_peaks) > 9:\n",
        "                RR_ave = (signal_peaks[-2] - signal_peaks[-10]) // 8\n",
        "                RR_missed = int(1.66 * RR_ave)\n",
        "                if peak - last_peak > RR_missed:\n",
        "                    missed_peaks = peaks[last_index + 1 : index]\n",
        "                    missed_peaks = missed_peaks[\n",
        "                        (missed_peaks > last_peak + min_missed_distance)\n",
        "                        & (missed_peaks < peak - min_missed_distance)\n",
        "                    ]\n",
        "                    threshold_I2 = 0.5 * threshold_I1\n",
        "                    missed_peaks = missed_peaks[detection[missed_peaks] > threshold_I2]\n",
        "                    if len(missed_peaks) > 0:\n",
        "                        signal_peaks[-1] = missed_peaks[np.argmax(detection[missed_peaks])]\n",
        "                        signal_peaks.append(peak)\n",
        "\n",
        "            last_peak = peak\n",
        "            last_index = index\n",
        "\n",
        "            SPKI = 0.125 * peak_value + 0.875 * SPKI\n",
        "        else:\n",
        "            NPKI = 0.125 * peak_value + 0.875 * NPKI\n",
        "\n",
        "    return signal_peaks\n",
        "\n",
        "def moving_window_integration(signal, window_size):\n",
        "    window_size = int(window_size)\n",
        "\n",
        "    mwa = ndimage.uniform_filter1d(signal, window_size, origin=(window_size - 1) // 2)\n",
        "\n",
        "    head_size = min(window_size - 1, len(signal))\n",
        "    mwa[:head_size] = np.cumsum(signal[:head_size]) / np.linspace(1, head_size, head_size)\n",
        "    return mwa\n",
        "\n",
        "def squaring(input_signal):\n",
        "    return np.square(input_signal)\n",
        "\n",
        "def derivative(input_signal, sampled_frequency):\n",
        "    return derivative_difference_equation(input_signal, sampled_frequency)\n",
        "\n",
        "def bandpass_filter(input_signal, low, high, sampling_freq):\n",
        "    return highpass_filter(lowpass_filter(input_signal, high, sampling_freq), low, sampling_freq)\n",
        "\n",
        "def lowpass_filter(input_signal, cutoff, sampling_freq):\n",
        "    return low_pass_scipy_butterworth(input_signal, cutoff, sampling_freq)\n",
        "\n",
        "def highpass_filter(input_signal, cutoff, sampling_freq):\n",
        "    return high_pass_scipy_butterworth(input_signal, cutoff, sampling_freq)\n",
        "\n",
        "def derivative_numpy(input_signal, sampling_frequency):\n",
        "    return np.diff(input_signal)\n",
        "\n",
        "# y(n) = (1/8)*T \n",
        "#        *[-x(n-2) -2*x(n-1) +2x(n+1) +x(n+2)]\n",
        "def derivative_difference_equation(input_signal, sampled_frequency):\n",
        "    derived_signal = input_signal.copy()\n",
        "    for index in range(len(input_signal)):\n",
        "        derived_sample = derived_signal[index]\n",
        "        if (index >= 2): derived_sample -= input_signal[index-2]\n",
        "        if (index >= 1): derived_sample -= 2*input_signal[index-1]\n",
        "        \n",
        "        if (index < len(input_signal)-1): derived_sample += 2*input_signal[index+1]\n",
        "        if (index < len(input_signal)-2): derived_sample += input_signal[index+2]\n",
        "    \n",
        "    derived_signal = derived_signal / ((1/8)*(1/sampled_frequency))\n",
        "    return derived_signal\n",
        "\n",
        "def low_pass_scipy_butterworth(input_signal, cutoff_freq, sampling_freq):\n",
        "    sos = signal.butter(2, cutoff_freq/(sampling_freq/2), 'low', output='sos')\n",
        "    filtered_signal = signal.sosfilt(sos, input_signal)\n",
        "    return filtered_signal\n",
        "\n",
        "def high_pass_scipy_butterworth(input_signal, cutoff_freq, sampling_freq):\n",
        "    sos = signal.butter(1, cutoff_freq/(sampling_freq/2), 'high', output='sos')\n",
        "    filtered_signal = signal.sosfilt(sos, input_signal)\n",
        "    return filtered_signal"
      ],
      "metadata": {
        "id": "Tbju7xTzSin_"
      },
      "execution_count": 15,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "h5IcQzxER6ZV"
      },
      "source": [
        "## Run Method"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def pre_low_pass(input_signal, sampling_freq):\n",
        "    sos = signal.butter(2, 0.683/(sampling_freq/2), 'high', output='sos')\n",
        "    filtered_signal = signal.sosfilt(sos, input_signal)\n",
        "    return filtered_signal"
      ],
      "metadata": {
        "id": "C9K4PxrOW-vb"
      },
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "id": "eOAXRSBeR6ZV"
      },
      "outputs": [],
      "source": [
        "def run_pantompkins(path, lead, low_cutoff, high_cutoff, sampling_freq, signal_length):\n",
        "    \n",
        "    example_path = path\n",
        "    leads = [lead]\n",
        "\n",
        "    raw_samples, real_peaks= readin.get_data(example_path, leads, 0, signal_length)\n",
        "    raw_samples = raw_samples.squeeze()\n",
        "    \n",
        "    pre_low = pre_low_pass(raw_samples, sampling_freq)\n",
        "\n",
        "    low_pass = lowpass_filter(pre_low[100:], high_cutoff, sampling_freq)\n",
        "    high_pass = highpass_filter(low_pass, low_cutoff, sampling_freq)\n",
        "\n",
        "    derived = derivative(high_pass, sampling_freq)\n",
        "    squared = squaring(derived)\n",
        "\n",
        "    mvg = moving_window_integration(squared, int(0.15*sampling_freq))\n",
        "\n",
        "    peaks = pan_tompkins(pre_low, sampling_freq, low_cutoff, high_cutoff)\n",
        "    fig, axs = plt.subplots(8, figsize=(15, 40))\n",
        "    axs[0].plot(raw_samples)\n",
        "    axs[0].title.set_text('a) Raw')\n",
        "    axs[1].plot(pre_low)\n",
        "    axs[1].title.set_text('b) Shifted')\n",
        "    axs[2].plot(high_pass)\n",
        "    axs[2].title.set_text('c) Bandpass')\n",
        "    axs[3].plot(derived)\n",
        "    axs[3].title.set_text('d) Derivative')\n",
        "    axs[4].plot(squared)\n",
        "    axs[4].title.set_text('e) Squaring')\n",
        "    axs[5].plot(mvg)\n",
        "    axs[5].title.set_text('f) Moving Average')\n",
        "    shift_back = []\n",
        "    for peak in peaks:\n",
        "      shift_back.append(peak+100)\n",
        "    display.np_mark_peaks(axs[6], pre_low, shift_back, 'g) Peaks')\n",
        "    display.np_mark_peaks(axs[7], pre_low, real_peaks, 'h) Annotations')\n",
        "\n",
        "    real_predicted = [i for i in real_peaks if i>100]\n",
        "    return shift_back, real_predicted\n",
        "\n",
        "def evaluation(peaks, real_peaks, interval):\n",
        "    check_peaks = real_peaks[1:]\n",
        "    n_ref = len(check_peaks)\n",
        "    n_detected = len(peaks)\n",
        "    count = 0\n",
        "    for i in range(n_ref):\n",
        "        correct = check_peaks[i]\n",
        "        found = np.where(np.logical_and(peaks>=correct-interval, peaks<=correct+interval))\n",
        "        if len(found) >= 1:\n",
        "            count += 1\n",
        "    sensitivity = count/n_ref\n",
        "    ppv = count/n_detected\n",
        "    f1 = 2*ppv*sensitivity/(ppv+sensitivity)\n",
        "    result = {\"sensitivity\": str(sensitivity*100)+'%',\n",
        "              'PPV': str(ppv*100)+'%',\n",
        "              'F1': str(f1*100) + '%'\n",
        "              }\n",
        "    return result"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "id": "EJisslpmR6ZV"
      },
      "outputs": [],
      "source": [
        "def test_pantompkins(path, lead, low_cutoff, high_cutoff, sampling_freq, signal_length):\n",
        "    \n",
        "    example_path = path\n",
        "    leads = [lead]\n",
        "\n",
        "    raw_samples, real_peaks= readin.get_data(example_path, leads, 0, signal_length)\n",
        "    raw_samples = raw_samples.squeeze()\n",
        "    samples =raw_samples - np.mean(raw_samples)\n",
        "\n",
        "    peaks = pan_tompkins(samples, sampling_freq, low_cutoff, high_cutoff)\n",
        "\n",
        "    return peaks, real_peaks"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Low pass methods"
      ],
      "metadata": {
        "id": "k2eru3swWXMG"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "spath = '/content/physionet.org/files/nsrdb/1.0.0/16272'\n",
        "print('Clean Signal')\n",
        "peaks, real_peaks = run_pantompkins(spath, 'ECG1', 5, 11, 360, 3000)\n",
        "evaluation(peaks, real_peaks, int(150/(1000/360)))"
      ],
      "metadata": {
        "id": "8LkeyzkRWWe3"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "id": "ETZi5YWtR6ZX",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 183
        },
        "outputId": "4c5e253c-11ac-4262-a422-c8c193302248"
      },
      "outputs": [
        {
          "output_type": "error",
          "ename": "NameError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-8-54c4797ce1a8>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mannots\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mwfdb\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrdann\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'../../datasets/mit-af/07162'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'atr'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msampfrom\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msampto\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m1000\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m \u001b[0mannots\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msample\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mNameError\u001b[0m: name 'wfdb' is not defined"
          ]
        }
      ],
      "source": [
        "annots = wfdb.rdann('../../datasets/mit-af/07162', 'atr', sampfrom=0, sampto=1000)\n",
        "annots.sample"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "eEeBpqVMR6ZX"
      },
      "outputs": [],
      "source": [
        "print('AF Signal')\n",
        "peaks, real_peaks = run_pantompkins('....//datasets/mit-af/07162', 'ECG2', 5, 128, 1000)\n",
        "evaluation(peaks, real_peaks, int(150/(1000/360)))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jsdkTEqfR6ZX"
      },
      "source": [
        "## Run on Whole Dataset"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "IoxurwUUR6ZX"
      },
      "outputs": [],
      "source": [
        "import os\n",
        "import glob"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "id": "kdl7ToxsR6ZX"
      },
      "outputs": [],
      "source": [
        "arr = os.listdir('/content/physionet.org/files/nsrdb/1.0.0')\n",
        "\n",
        "sample_ids = []\n",
        "for file in arr:\n",
        "    if '.atr' in file:\n",
        "        sample_ids.append(file[:5])\n",
        "        "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "ENyLPmidR6ZY"
      },
      "outputs": [],
      "source": [
        "root_folder = '/content/physionet.org/files/nsrdb/1.0.0/'\n",
        "sensitivity = []\n",
        "ppv = []\n",
        "f1 = []\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "id": "rNS85BV9R6ZY",
        "outputId": "603e4225-b501-40e5-f0ae-679532d5b6e2",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[]"
            ]
          },
          "metadata": {},
          "execution_count": 5
        }
      ],
      "source": [
        "sensitivity"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "id": "DckRtyjKR6ZY",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 235
        },
        "outputId": "4d215ace-4807-4a73-fdf4-45c1f43807ad"
      },
      "outputs": [
        {
          "output_type": "error",
          "ename": "NameError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-6-15425a1a6819>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mid\u001b[0m \u001b[0;32min\u001b[0m \u001b[0msample_ids\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m8\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m     \u001b[0msample_path\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mroot_folder\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mid\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m     \u001b[0mpeaks\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mreal_peaks\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mrun_pantompkins\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msample_path\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'ECG2'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m5\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m11\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m128\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m60\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0;36m60\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0;36m128\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      4\u001b[0m     \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'hi'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m     \u001b[0mres\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mevaluation\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpeaks\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mreal_peaks\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m150\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1000\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0;36m128\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mNameError\u001b[0m: name 'run_pantompkins' is not defined"
          ]
        }
      ],
      "source": [
        "for id in sample_ids[8:]:\n",
        "    sample_path = root_folder + id\n",
        "    peaks, real_peaks = run_pantompkins(sample_path, 'ECG2', 5, 11, 128, 60*60*128)\n",
        "    print('hi')\n",
        "    res = evaluation(peaks, real_peaks, int(150/(1000/128)))\n",
        "    sensitivity.append(res['sensitivity'])\n",
        "    ppv.append(res['PPV'])\n",
        "    f1.append(res['F1'])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "weNOd6jwR6ZY"
      },
      "outputs": [],
      "source": [
        "def to_float(arr):\n",
        "    ret = []\n",
        "    for x in arr:\n",
        "        ret.append(float(x[0:-1]))\n",
        "    return ret "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "CD9itEcYR6ZY",
        "outputId": "4deda8e4-e5f8-480b-e544-a7fa79c4fe3e"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<matplotlib.legend.Legend at 0x2b413cca790>"
            ]
          },
          "execution_count": 41,
          "metadata": {},
          "output_type": "execute_result"
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 1080x360 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "plt.figure(figsize=(15,5))\n",
        "plt.xlabel('Sample ID')\n",
        "plt.ylabel('Percentage')\n",
        "\n",
        "plt.plot(sample_ids, to_float(sensitivity), label='Sensitivity', marker='o', linestyle='--')\n",
        "plt.plot(sample_ids, to_float(ppv), label='PPV', marker='o', linestyle='--')\n",
        "plt.plot(sample_ids, to_float(f1), label='F1', marker='o', linestyle='--')\n",
        "\n",
        "plt.legend()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "SHE7WpnlR6ZY",
        "outputId": "fef61dc8-aa07-4224-c7f9-90f0e9081d7e"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "(88.70252930995336, 94.52263293614219, 90.48624490723604)"
            ]
          },
          "execution_count": 43,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "np.average(to_float(sensitivity)), np.average(to_float(ppv)), np.average(to_float(f1))"
      ]
    }
  ],
  "metadata": {
    "kernelspec": {
      "display_name": "base",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.9.7"
    },
    "orig_nbformat": 4,
    "vscode": {
      "interpreter": {
        "hash": "51480fad90fe9d21f60dbdf1474e71297e9cf7d519346d7c8ab062a40f50e1c0"
      }
    },
    "colab": {
      "provenance": [],
      "collapsed_sections": [
        "fRjCYnF-R6ZS",
        "h5IcQzxER6ZV",
        "k2eru3swWXMG"
      ],
      "include_colab_link": true
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}